// 背包工具

/**
 * 移动背包内物品到背包的新位置
 * @param {*} items 
 * @param {*} src_index 
 * @param {*} target_index 
 */
export function move_item_to_items_index(items, src_index, target_index) {
    if (src_index !== target_index && items[src_index] !== null && items[src_index] !== undefined) {
        if (items.length < target_index + 1) {
            //补充空位置
            for (let index = items.length; index < target_index; index++) {
                items.push(null);
            }
        }
        let src_item = Object.assign({}, items[src_index]);
        let target_item = items[target_index];
        //目标位置为空
        if (target_item === null || target_item === undefined) {
            //放到目标位置
            items[target_index] = src_item;
            //原位置置空
            items[src_index] = null;
        } else {
            //目标位置存在物品
            let target_tmp = Object.assign({}, target_item);
            //放到目标位置
            items[target_index] = src_item;
            //目标位置放到原位置
            items[src_index] = target_tmp;
        }
    }
}


/**
 * 将原背包物品移动到目标背包位置
 * @param {*} src_items 原背包
 * @param {*} target_items 目标背包
 * @param {*} src_index 原背包位置
 * @param {*} target_index 目标背包位置
 */
export function move_src_items_item_to_target_items_idnex(src_items, target_items, src_index, target_index) {
    if (src_items[src_index] !== null && src_items[src_index] !== undefined) {
        if (target_items.length < target_index + 1) {
            //补充空位置
            for (let index = target_items.length; index < target_index; index++) {
                if (target_items[index] === undefined) {
                    target_items[index](null);
                }
            }
        }
        //原来背包的物品(复制一份)
        let src_item = Object.assign({}, src_items[src_index]);
        //目标背包位置是空的
        if (target_items[target_index] === null || target_items[target_index] === undefined) {
            //放到目标背包位置
            target_items[target_index] = src_item;
            //删除原来位置的物品
            src_items[src_index] = null;
        } else {
            //将目标位置的物品与原背包物品互换
            let target_item = Object.assign({}, target_items[target_index]);
            //放到目标背包位置
            target_items[target_index] = src_item;
            //放回原背包
            src_items[src_index] = target_item;
        }
    }
}

/**
 * 叠加已存在物品到背包
 * @param {*} items 背包物品
 * @param {*} exist_item_data 已经存在的可叠加物品集合 [0] 背包内下标 [1] 物品
 * @param {*} num 需要放置的数量
 */
function add_superposition_exist_item_to_items(items, exist_item_data, num) {
    for (let index = 0; index < exist_item_data.length; index++) {
        let element = exist_item_data[index][1];
        //叠加数量上限
        let max_size = element["上限"] === undefined ? 999 : element["上限"];
        let edit_falg = false;
        //开始累加 num 次
        for (let index = num; index > 0; index--) {
            if (element["数量"] < max_size) {
                element["数量"] = element["数量"] + 1;
                edit_falg = true
                //成功叠加 减少一次需要叠加的数量
                num = num - 1;
            } else {
                //跳出，尝试往下一个已存在物品位置叠加
                break;
            }
        }
        if (edit_falg) {
            items[exist_item_data[index][0]] = element;
        }
    }
    return num;
}

/**
 * 向背包空位置放入可叠加物品
 * @param {*} items 背包物品
 * @param {*} empty_index 空位置
 * @param {*} item 物品
 * @param {*} num 需要放置的数量
 */
function add_superposition_item_to_empty_list_items(items, empty_index, item, num) {
    let max_size = item["上限"] === undefined ? 999 : item["上限"];
    for (let index = 0; index < empty_index.length; index++) {
        if (num > 0) {
            item["数量"] = 0;
            let tmp_item = Object.assign({}, item);
            for (let j = num; j > 0; j--) {
                if (tmp_item["数量"] < max_size) {
                    tmp_item["数量"] = tmp_item["数量"] + 1;
                    num = num - 1;
                } else {
                    break;
                }
            }
            //放入背包,往下一个下标走
            items[empty_index[index]] = tmp_item;
        } {
            break;
        }
    }
    return num;
}

/**
 * 向背包内放置新的可叠加物品
 * @param {*} items 背包物品
 * @param {*} item 要放置的物品
 * @param {*} num 需要放置的数量
 */
function add_superposition_new_item_to_items(items, item, num) {
    let max_size = item["上限"] === undefined ? 999 : item["上限"];
    let index = items.length;
    item["数量"] = 0;
    let tmp_item = Object.assign({}, item);
    while (num > 0) {
        if (tmp_item["数量"] < max_size) {
            tmp_item["数量"] = tmp_item["数量"] + 1;
            num = num - 1;
            items[index] = tmp_item;
        } else {
            //复制一份新的继续叠加
            Object.assign(tmp_item, item);
            index++;
        }
    }
    return num;
}

/**
 * 不可叠加物品放入空位置
 * @param {*} items 
 * @param {*} empty_index_list 
 * @param {*} item 
 * @param {*} num 
 */
function add_item_to_empty_list(items, empty_index_list, item, num) {
    for (let index = 0; index < empty_index_list.length; index++) {
        if (num > 0) {
            let empty_index = empty_index_list[index];
            items[empty_index] = item;
            //放一次则减少一次需要放置的数量
            num = num - 1;
        } else {
            break;
        }
    }
    return num;
}

/**
 * 物品放置逻辑
 * @param {*} items 包裹数据
 * @param {*} item 物品数据
 * @param {*} item 物品数量
 */
export function add_item_to_items(items, item, num = 1) {
    let empty_index_list = [];
    //已存在的物品  [0] 背包内下标 [1]物品
    let exist_item_data = [];
    //判断是否存在相同物品,并取出空位置索引
    for (let index = 0; index < items.length; index++) {
        if (items[index] === undefined || items[index] === null) {
            //空的位置
            empty_index_list.push(index);
        } else if (items[index]["名称"] === item["名称"]) {
            //已存在的物品
            exist_item_data.push([index, items[index]]);
        }
    }
    if (item["可叠加"]) {
        //向已存在道具进行叠加
        num = add_superposition_exist_item_to_items(items, exist_item_data, num);
        //没叠加完
        if (num > 0) {
            if (empty_index_list.length > 0) {
                //往空位置叠加
                num = add_superposition_item_to_empty_list_items(items, empty_index_list, item, num);
                if (num > 0) {
                    //空位置用完了,往新位置叠加
                    num = add_superposition_new_item_to_items(items, item, num);
                }
            } else {
                //没有空位置,往新位置叠加
                add_superposition_new_item_to_items(items, item, num);
            }
        }
        return items;
    } else {
        //不可叠加
        if (empty_index_list.length > 0) {
            //有空位置
            num = add_item_to_empty_list(items, empty_index_list, item, num);
            if (num > 0) {
                //空位置不够放,直接往最后的位置放
                for (let index = num; index > 0; index--) {
                    items.push(item);
                }
            }
        } else {
            //没有空位置，直接往最后的位置放
            for (let index = 0; index < num; index++) {
                items.push(item);
            }
        }

    }
}

/**
 * 校验物品集合内指定物品存在的数量
 * @param {*} items 
 * @param {*} item_name 
 * @returns [0] 总数量 [1] 下标位置和数量
 */
export function check_items_exist_item(items, item_name) {
    if (items === undefined) {
        return { "总数": 0, "详情": [] };
    }
    let exist_count = 0;
    let item_count_data = [];
    for (let index = 0; index < items.length; index++) {
        let item = items[index];
        if (item !== null && item["名称"] === item_name) {
            if (item["数量"]) {
                exist_count += item["数量"];
                item_count_data.push([index, item["数量"]]);
            } else {
                exist_count++;
                item_count_data.push([index, 1]);
            }
        }
    }
    return { "总数": 1, "详情": item_count_data };
}
